home *** CD-ROM | disk | FTP | other *** search
/ Aminet 2 / Aminet AMIGA CDROM (1994)(Walnut Creek)[Feb 1994][W.O. 44790-1].iso / Aminet / util / gnu / oleo_src.lha / src / parse.y < prev    next >
Text File  |  1992-07-27  |  17KB  |  876 lines
  1. %{
  2. /*    Copyright (C) 1990 Free Software Foundation, Inc.
  3.  
  4. This file is part of Oleo, the GNU Spreadsheet.
  5.  
  6. Oleo is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 1, or (at your option)
  9. any later version.
  10.  
  11. Oleo is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with Oleo; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19. %}
  20.  
  21. %right '?' ':'
  22. %left '|'
  23. %left '&'
  24. %nonassoc '=' NE
  25. %nonassoc '<' LE '>' GE
  26. %left '+' '-'
  27. %left '*' '/' '%'
  28. %right '^'
  29. %left NEG '!'
  30.  
  31. %token    L_CELL L_RANGE
  32. %token    L_VAR
  33.  
  34. %token    L_CONST
  35. %token    L_FN0    L_FN1    L_FN2    L_FN3    L_FN4    L_FNN
  36. %token    L_FN1R    L_FN2R    L_FN3R    L_FN4R    L_FNNR
  37.  
  38. %token    L_LE    L_NE    L_GE
  39.  
  40. %{
  41. #include "funcdef.h"
  42.  
  43. #include <ctype.h>
  44.  
  45. #define obstack_chunk_alloc ck_malloc
  46. #define obstack_chunk_free free
  47. #include "obstack.h"
  48. #include "sysdef.h"
  49.  
  50. #include "global.h"
  51. #include "errors.h"
  52. #include "node.h"
  53. #include "eval.h"
  54.  
  55. extern void *find_or_make_var EXT2(char *,int);
  56.  
  57. int yylex EXT0();
  58.  
  59. void yyerror EXT1(char *);
  60.  
  61. void *parse_hash;
  62. extern VOIDSTAR hash_find();
  63.  
  64. /* This table contains a list of the infix single-char functions */
  65. unsigned char fnin[] = {
  66.     SUM, DIFF, DIV, PROD, MOD, /* AND, OR, */ POW, EQUAL, IF, CONCAT, 0
  67. };
  68.  
  69. #define YYSTYPE _y_y_s_t_y_p_e
  70. typedef struct node *YYSTYPE;
  71. YYSTYPE make_list EXT2(YYSTYPE, YYSTYPE);
  72. YYSTYPE parse_return;
  73.  
  74. char *instr;
  75. int parse_error = 0;
  76. extern struct obstack tmp_mem;
  77.  
  78. %}
  79. %%
  80. line:    exp
  81.         { parse_return=$1; }
  82.     | error {
  83.         if(!parse_error)
  84.             parse_error=PARSE_ERR;
  85.         parse_return=0; }
  86.     ;
  87.  
  88. exp:      L_CONST
  89.     | cell
  90.     | L_FN0 '(' ')' {
  91.         $$=$1; }
  92.     | L_FN1 '(' exp ')' {
  93.         ($1)->n_x.v_subs[0]=$3;
  94.         ($1)->n_x.v_subs[1]=(struct node *)0;
  95.         $$=$1; }
  96.     | L_FN2 '(' exp ',' exp ')' {
  97.         ($1)->n_x.v_subs[0]=$3;
  98.         ($1)->n_x.v_subs[1]=$5;
  99.         $$=$1; }
  100.     | L_FN3 '(' exp ',' exp ',' exp ')' {
  101.         ($1)->n_x.v_subs[0]=make_list($3,$5);
  102.          ($1)->n_x.v_subs[1]=$7;
  103.          $$=$1;}
  104.     | L_FN4 '(' exp ',' exp ',' exp ',' exp ')' {
  105.         ($1)->n_x.v_subs[0]=make_list($3,$5);
  106.          ($1)->n_x.v_subs[1]=make_list($7,$9);
  107.          $$=$1;}
  108.     | L_FNN '(' exp_list ')' {
  109.         ($1)->n_x.v_subs[0]=(struct node *)0;
  110.         ($1)->n_x.v_subs[1]=$3;
  111.         $$=$1; }
  112.     | L_FN1R '(' L_RANGE ')' {
  113.         $1->n_x.v_subs[0]=$3;
  114.         $$=$1; }
  115.     | L_FN1R '(' L_VAR ')' {
  116.         $1->n_x.v_subs[0]=$3;
  117.         $$=$1; }
  118.  
  119.     | L_FN2R '(' L_RANGE ',' exp ')' {
  120.         $1->n_x.v_subs[0]=$3;
  121.         $1->n_x.v_subs[1]=$5;
  122.         $$=$1; }
  123.     | L_FN2R '(' L_VAR ',' exp ')' {
  124.         $1->n_x.v_subs[0]=$3;
  125.         $1->n_x.v_subs[1]=$5;
  126.         $$=$1; }
  127.  
  128.     /* JF:  These should be FN2R, but I'm hacking this for SYLNK */
  129.     | L_FN2R '(' L_RANGE ',' exp ',' exp ')' {
  130.         if($1->comp_value!=F_INDEX)
  131.             parse_error=PARSE_ERR;
  132.         $1->comp_value=F_INDEX2;
  133.         $1->n_x.v_subs[0]=make_list($3,$5);
  134.         $1->n_x.v_subs[1]=$7;
  135.         $$=$1; }
  136.     | L_FN2R '(' L_VAR ',' exp ',' exp ')' {
  137.         if($1->comp_value!=F_INDEX)
  138.             parse_error=PARSE_ERR;
  139.         $1->comp_value=F_INDEX2;
  140.         $1->n_x.v_subs[0]=make_list($3,$5);
  141.         $1->n_x.v_subs[1]=$7;
  142.         $$=$1; }
  143.  
  144.     | L_FN3R '(' L_RANGE ',' exp ',' exp ')' {
  145.         ($1)->n_x.v_subs[0]=make_list($3,$5);
  146.          ($1)->n_x.v_subs[1]=$7;
  147.          $$=$1;}
  148.     | L_FN3R '(' L_VAR ',' exp ',' exp ')' {
  149.         ($1)->n_x.v_subs[0]=make_list($3,$5);
  150.          ($1)->n_x.v_subs[1]=$7;
  151.          $$=$1;}
  152.  
  153.     | L_FNNR '(' range_exp_list ')' {
  154.         ($1)->n_x.v_subs[0]=(struct node *)0;
  155.         ($1)->n_x.v_subs[1]=$3;
  156.         $$=$1; }
  157.     | exp '?' exp ':' exp {
  158.         $2->comp_value=IF;
  159.         $2->n_x.v_subs[0]=$4;
  160.         $2->n_x.v_subs[1]=$5;
  161.         $4->n_x.v_subs[0]=$1;
  162.         $4->n_x.v_subs[1]=$3;
  163.         $$=$2; }
  164.     /* | exp '|' exp {
  165.         $2->n_x.v_subs[0]=$1;
  166.         $2->n_x.v_subs[1]=$3;
  167.         $$ = $2; } */
  168.     | exp '&' exp {
  169.         /* $2->n_x.v_subs[0]=make_list($1,make_list($3,0));
  170.         $2->n_x.v_subs[1]=0; */
  171.  
  172.         $2->n_x.v_subs[0]=$1;
  173.         $2->n_x.v_subs[1]=$3;
  174.         $$ = $2; }
  175.     | exp '<' exp {
  176.         $2->n_x.v_subs[0]=$1;
  177.         $2->n_x.v_subs[1]=$3;
  178.         $$ = $2; }
  179.     | exp LE exp {
  180.         $2->n_x.v_subs[0]=$1;
  181.         $2->n_x.v_subs[1]=$3;
  182.         $$ = $2; }
  183.     | exp '=' exp {
  184.         $2->n_x.v_subs[0]=$1;
  185.         $2->n_x.v_subs[1]=$3;
  186.         $$ = $2; }
  187.     | exp NE exp {
  188.         $2->n_x.v_subs[0]=$1;
  189.         $2->n_x.v_subs[1]=$3;
  190.         $$ = $2; }
  191.     | exp '>' exp {
  192.         $2->n_x.v_subs[0]=$1;
  193.         $2->n_x.v_subs[1]=$3;
  194.         $$ = $2; }
  195.     | exp GE exp {
  196.         $2->n_x.v_subs[0]=$1;
  197.         $2->n_x.v_subs[1]=$3;
  198.         $$ = $2; }
  199.     | exp '+' exp {
  200.         $2->n_x.v_subs[0]=$1;
  201.         $2->n_x.v_subs[1]=$3;
  202.         $$ = $2; }
  203.     | exp '-' exp {
  204.         $2->n_x.v_subs[0]=$1;
  205.         $2->n_x.v_subs[1]=$3;
  206.         $$ = $2; }
  207.     | exp '*' exp {
  208.         $2->n_x.v_subs[0]=$1;
  209.         $2->n_x.v_subs[1]=$3;
  210.         $$ = $2; }
  211.     | exp '/' exp {
  212.         $2->n_x.v_subs[0]=$1;
  213.         $2->n_x.v_subs[1]=$3;
  214.         $$ = $2; }
  215.     | exp '%' exp {
  216.         $2->n_x.v_subs[0]=$1;
  217.         $2->n_x.v_subs[1]=$3;
  218.         $$ = $2; }
  219.     | exp '^' exp {
  220.         $2->n_x.v_subs[0]=$1;
  221.         $2->n_x.v_subs[1]=$3;
  222.         $$ = $2; }
  223.     | '-' exp %prec NEG {
  224.         if($2->comp_value==CONST_FLT) {
  225.             $2->n_x.v_float= -($2->n_x.v_float);
  226.             /* free($1); */
  227.             $$=$2;
  228.         } else if($2->comp_value==CONST_INT) {
  229.             $2->n_x.v_int= -($2->n_x.v_int);
  230.             /* free($1); */
  231.             $$=$2;
  232.         } else {
  233.             $1->comp_value = NEGATE;
  234.             $1->n_x.v_subs[0]=$2;
  235.             $1->n_x.v_subs[1]=(struct node *)0;
  236.             $$ = $1;
  237.         } }
  238.     | '!' exp {
  239.         $1->n_x.v_subs[0]=$2;
  240.         $1->n_x.v_subs[1]=(struct node *)0;
  241.         $$ = $1; }
  242.     | '(' exp ')'
  243.         { $$ = $2; }
  244.     | '(' exp error {
  245.         if(!parse_error)
  246.             parse_error=NO_CLOSE;
  247.         }
  248.     /* | exp ')' error {
  249.         if(!parse_error)
  250.             parse_error=NO_OPEN;
  251.         } */
  252.     | '(' error {
  253.         if(!parse_error)
  254.             parse_error=NO_CLOSE;
  255.         }
  256.     ;
  257.  
  258.  
  259. exp_list: exp
  260.          { $$ = make_list($1, 0); }
  261.     | exp_list ',' exp
  262.         { $$ = make_list($3, $1); }
  263.     ;
  264.  
  265. range_exp: L_RANGE
  266.     | exp
  267.     ;
  268.  
  269. range_exp_list: range_exp
  270.         { $$=make_list($1, 0); }
  271.     |   range_exp_list ',' range_exp
  272.         { $$=make_list($3,$1); }
  273.     ;
  274.  
  275. cell:    L_CELL
  276.         { $$=$1; }
  277.     | L_VAR
  278.     ;
  279. %%
  280.  
  281. void
  282. yyerror FUN1(char *, s)
  283. {
  284.     if(!parse_error)
  285.         parse_error=PARSE_ERR;
  286. }
  287.  
  288. YYSTYPE
  289. make_list FUN2(YYSTYPE, car, YYSTYPE, cdr)
  290. {
  291.     YYSTYPE ret;
  292.  
  293.     ret=(YYSTYPE)obstack_alloc(&tmp_mem,sizeof(*ret));
  294.     ret->comp_value = 0;
  295.     ret->n_x.v_subs[0]=car;
  296.     ret->n_x.v_subs[1]=cdr;
  297.     return ret;
  298. }
  299.  
  300. #define ERROR -1
  301.  
  302. extern struct node *yylval;
  303.  
  304. unsigned char parse_cell_or_range EXT2(char **,struct rng *);
  305.  
  306. int
  307. yylex FUN0()
  308. {
  309.     int ch;
  310.     struct node *new;
  311.     int isflt;
  312.     char *begin;
  313.     char *tmp_str;
  314.     unsigned char byte_value;
  315.     int n;
  316.  
  317.     /* unsigned char *ptr; */
  318.     int nn;
  319.     struct function *fp;
  320.     int tmp_ch;
  321.  
  322. #ifdef TEST
  323.     if(!instr)
  324.         return ERROR;
  325. #endif
  326.     while(isspace(*instr))
  327.         instr++;
  328.     ch = *instr++;
  329.     if(ch=='(' || ch==',' || ch==')')
  330.         return ch;
  331.  
  332.     new=(struct node *)obstack_alloc(&tmp_mem,sizeof(struct node));
  333.     new->add_byte=0;
  334.     new->sub_value=0;
  335.     switch(ch) {
  336.     case 0:
  337.         return 0;
  338.  
  339.     case '0': case '1': case '2': case '3': case '4': case '5': case '6':
  340.     case '7': case '8': case '9': case '.':
  341.         isflt = (ch=='.');
  342.  
  343.         begin=instr-1;
  344.         tmp_str=instr;
  345.  
  346.         while(isdigit(*tmp_str) || (!isflt && *tmp_str=='.' && ++isflt))
  347.             tmp_str++;
  348.         if(*tmp_str=='e' || *tmp_str=='E') {
  349.             isflt=1;
  350.             tmp_str++;
  351.             if(*tmp_str=='-' || *tmp_str=='+')
  352.                 tmp_str++;
  353.             while(isdigit(*tmp_str))
  354.                 tmp_str++;
  355.         }
  356.         if(isflt) {
  357.             new->n_x.v_float=astof((char **)(&begin));
  358.             byte_value=CONST_FLT;
  359.         } else {
  360.             new->n_x.v_int=astol((char **)(&begin));
  361.             if(begin!=tmp_str) {
  362.                 begin=instr-1;
  363.                 new->n_x.v_float=astof((char **)(&begin));
  364.                 byte_value=CONST_FLT;
  365.             } else
  366.                 byte_value=CONST_INT;
  367.         }
  368.         ch=L_CONST;
  369.         instr=begin;
  370.         break;
  371.  
  372.     case '"':
  373.         begin=instr;
  374.         while(*instr && *instr!='"') {
  375.             if(*instr=='\\' && instr[1])
  376.                 instr++;
  377.             instr++;
  378.         }
  379.         if(!*instr) {
  380.             parse_error=NO_QUOTE;
  381.             return ERROR;
  382.         }
  383.         tmp_str=new->n_x.v_string=(char *)ck_malloc(1+instr-begin);
  384.         while(begin!=instr) {
  385.             unsigned char n;
  386.  
  387.             if(*begin=='\\') {
  388.                 begin++;
  389.                 if(begin[0]>='0' && begin[0]<='7') {
  390.                     if(begin[1]>='0' && begin[1]<='7') {
  391.                         if(begin[2]>='0' && begin[2]<='7') {
  392.                             n=(begin[2]-'0') + (010 * (begin[1]-'0')) + ( 0100 * (begin[0]-'0'));
  393.                             begin+=3;
  394.                         } else {
  395.                             n=(begin[1]-'0') + (010 * (begin[0]-'0'));
  396.                             begin+=2;
  397.                         }
  398.                     } else {
  399.                         n=begin[0]-'0';
  400.                         begin++;
  401.                     }
  402.                 } else
  403.                     n= *begin++;
  404.                 *tmp_str++= n;
  405.             } else
  406.                 *tmp_str++= *begin++;
  407.         }
  408.         *tmp_str='\0';
  409.         instr++;
  410.         byte_value=CONST_STR;
  411.         ch=L_CONST;
  412.         break;
  413.  
  414.     case '+':    case '-':
  415.  
  416.     case '*':    case '/':    case '%':    case '&':
  417.     case '|':    case '^':    case '=':
  418.  
  419.     case '?':
  420.     {
  421.         unsigned char *ptr;
  422.  
  423.         for(ptr= fnin;*ptr;ptr++)
  424.             if(the_funs[*ptr].fn_str[0]==ch)
  425.                 break;
  426. #ifdef TEST
  427.         if(!*ptr)
  428.             panic("Can't find fnin[] entry for '%c'",ch);
  429. #endif
  430.         byte_value= *ptr;
  431.     }
  432.         break;
  433.  
  434.     case ':':
  435.         byte_value=IF;
  436.         break;
  437.  
  438.     case '!':
  439.     case '<':
  440.     case '>':
  441.         if(*instr!='=') {
  442.             byte_value = (ch=='<') ? LESS : (ch=='>') ? GREATER : NOT;
  443.             break;
  444.         }
  445.         instr++;
  446.         byte_value = (ch=='<') ? LESSEQ : (ch=='>') ? GREATEQ : NOTEQUAL;
  447.         ch = (ch=='<') ? LE : (ch=='>') ? GE : NE;
  448.         break;
  449.  
  450. #ifndef A0_REFS
  451.     case '$':
  452.     case '@':
  453. #endif
  454.     case '\'':
  455.     case ';':
  456.     case '[':
  457.     case '\\':
  458.     case ']':
  459.     case '`':
  460.     case '{':
  461.     case '}':
  462.     case '~':
  463.         parse_error=BAD_CHAR;
  464.         return ERROR;
  465.  
  466.     case '#':
  467.         begin=instr-1;
  468.         while(*instr && (isalnum(*instr) || *instr=='_'))
  469.             instr++;
  470.         ch= *instr;
  471.         *instr=0;
  472.         if(!stricmp(begin,tname))
  473.             byte_value=F_TRUE;
  474.         else if(!stricmp(begin,fname))
  475.             byte_value=F_FALSE;
  476.         else if(!stricmp(begin,iname) && (begin[4]==0 || !stricmp(begin+4,"inity")))
  477.             byte_value=CONST_INF;
  478.         else if(!stricmp(begin,mname) ||
  479.             !stricmp(begin,"#ninf"))
  480.             byte_value=CONST_NINF;
  481.         else if(!stricmp(begin,nname) ||
  482.             !stricmp(begin,"#nan"))
  483.             byte_value=CONST_NAN;
  484.         else {
  485.             for(n=1;n<=ERR_MAX;n++)
  486.                 if(!stricmp(begin,ename[n]))
  487.                     break;
  488.             if(n>ERR_MAX)
  489.                 n=BAD_CHAR;
  490.             new->n_x.v_int=n;
  491.             byte_value=CONST_ERR;
  492.         }
  493.         *instr=ch;
  494.         ch=L_CONST;
  495.         break;
  496.  
  497.     default:
  498.         begin=instr-1;
  499.         byte_value=parse_cell_or_range(&begin,&(new->n_x.v_rng));
  500.         if(byte_value) {
  501.             if((byte_value& ~0x3)==R_CELL)
  502.                 ch=L_CELL;
  503.             else
  504.                 ch=L_RANGE;
  505.             instr=begin;
  506.             break;
  507.         }
  508.  
  509.         while(*instr && (isalpha(*instr) || isdigit(*instr) || *instr=='_'))
  510.             instr++;
  511.  
  512.         n=instr-begin;
  513.         while(isspace(*instr))
  514.             instr++;
  515.  
  516. #ifndef A0_REFS
  517.         if(*instr!='(') {
  518. #endif
  519.             ch=L_VAR;
  520.             byte_value=VAR;
  521.             new->n_x.v_var=find_or_make_var(begin,n);
  522.             break;
  523. #ifndef A0_REFS
  524.         }
  525. #endif
  526. #ifdef A0_REFS
  527.  
  528.     case '@':
  529.         begin=instr;
  530.         while(*instr && (isalpha(*instr) || isdigit(*instr) || *instr=='_'))
  531.             instr++;
  532.         n=instr-begin;
  533. #endif
  534.         tmp_ch=begin[n];
  535.         begin[n]='\0';
  536.         fp=hash_find(parse_hash,begin);
  537.         begin[n]=tmp_ch;
  538.         byte_value= ERROR;
  539.         if(!fp) {
  540.             parse_error=BAD_FUNC;
  541.             return ERROR;
  542.         }
  543.  
  544.         if(fp>=the_funs && fp<=&the_funs[USR1])
  545.             byte_value=fp-the_funs;
  546.         else {
  547.             for(nn=0;nn<n_usr_funs;nn++) {
  548.                 if(fp>=&usr_funs[nn][0] && fp<=&usr_funs[nn][usr_n_funs[nn]]) {
  549.                     byte_value=USR1+nn;
  550.                     new->sub_value=fp-&usr_funs[nn][0];
  551.                     break;
  552.                 }
  553.             }
  554. #ifdef TEST
  555.             if(nn==n_usr_funs) {
  556.                 error_msg("Couln't turn fp into a ##");
  557.                 parse_error=BAD_FUNC;
  558.                 return ERROR;
  559.             }
  560. #endif
  561.         }
  562.  
  563.         if(fp->fn_argn&X_J)
  564.             ch= byte_value==F_IF ? L_FN3 : L_FN2;
  565.         else if(fp->fn_argt[0]=='R' || fp->fn_argt[0]=='E')
  566.             ch=L_FN1R-1+fp->fn_argn-X_A0;
  567.         else
  568.             ch=L_FN0 + fp->fn_argn-X_A0;
  569.  
  570.         break;
  571.     }
  572.     /* new->node_type=ch; */
  573.     new->comp_value=byte_value;
  574.     yylval=new;
  575.     return ch;
  576. }
  577.  
  578. /* Return value is
  579.     0 if it doesn't look like a cell or a range,
  580.     R_CELL if it is a cell (ptr now points past the characters, lr and lc hold the row and col of the cell)
  581.     RANGE if it is a range (ptr points past the chars)
  582.  */
  583. unsigned char
  584. parse_cell_or_range FUN2(char **,ptr, struct rng *,retp)
  585. {
  586. #ifdef A0_REFS
  587.     unsigned tmpc,tmpr;
  588.     char *p;
  589.     int abz = ROWREL|COLREL;
  590.     int str_to_col EXT1(char **);
  591.  
  592.     p= *ptr;
  593.     tmpc=0;
  594.     if(*p=='$') {
  595.         abz-=COLREL;
  596.         p++;
  597.     }
  598.     if(!isalpha(*p))
  599.         return 0;
  600.     tmpc=str_to_col(&p);
  601.     if(tmpc<MIN_COL || tmpc>MAX_COL)
  602.         return 0;
  603.     if(*p=='$') {
  604.         abz-=ROWREL;
  605.         p++;
  606.     }
  607.     if(!isdigit(*p))
  608.         return 0;
  609.     for(tmpr=0;isdigit(*p);p++)
  610.         tmpr=tmpr*10 + *p - '0';
  611.  
  612.     if(tmpr<MIN_ROW || tmpr>MAX_ROW)
  613.         return 0;
  614.  
  615.     if(*p==':' || *p=='.') {
  616.         unsigned tmpc1,tmpr1;
  617.  
  618.         abz = ((abz&COLREL) ? LCREL : 0)|((abz&ROWREL) ? LRREL : 0)|HRREL|HCREL;
  619.         p++;
  620.         if(*p=='$') {
  621.             abz-=HCREL;
  622.             p++;
  623.         }
  624.         if(!isalpha(*p))
  625.             return 0;
  626.         tmpc1=str_to_col(&p);
  627.         if(tmpc1<MIN_COL || tmpc1>MAX_COL)
  628.             return 0;
  629.         if(*p=='$') {
  630.             abz-=HRREL;
  631.             p++;
  632.         }
  633.         if(!isdigit(*p))
  634.             return 0;
  635.         for(tmpr1=0;isdigit(*p);p++)
  636.             tmpr1=tmpr1*10 + *p - '0';
  637.         if(tmpr1<MIN_ROW || tmpr1>MAX_ROW)
  638.             return 0;
  639.  
  640.         if(tmpr<tmpr1) {
  641.             retp->lr=tmpr;
  642.             retp->hr=tmpr1;
  643.         } else {
  644.             retp->lr=tmpr1;
  645.             retp->hr=tmpr;
  646.         }
  647.         if(tmpc<tmpc1) {
  648.             retp->lc=tmpc;
  649.             retp->hc=tmpc1;
  650.         } else {
  651.             retp->lc=tmpc1;
  652.             retp->hc=tmpc;
  653.         }
  654.         *ptr= p;
  655.         return RANGE | abz;
  656.     }
  657.     retp->lr = retp->hr = tmpr;
  658.     retp->lc = retp->hc = tmpc;
  659.     *ptr=p;
  660.     return R_CELL | abz;
  661. #else
  662.     char *p;
  663.     unsigned char retr;
  664.     unsigned char retc;
  665.     int ended;
  666.     long num;
  667.     CELLREF tmp;
  668.  
  669.     extern CELLREF cur_row, cur_col;
  670.  
  671. #define CK_ABS_R(x)    if((x)<MIN_ROW || (x)>MAX_ROW)    \
  672.                 return 0;        \
  673.             else
  674.  
  675. #define CK_REL_R(x)    if(   ((x)>0 && MAX_ROW-(x)<cur_row)    \
  676.                || ((x)<0 && MIN_ROW-(x)>cur_row))    \
  677.                 return 0;            \
  678.             else
  679.  
  680. #define CK_ABS_C(x)    if((x)<MIN_COL || (x)>MAX_COL)    \
  681.                 return 0;        \
  682.             else
  683.  
  684. #define CK_REL_C(x)    if(   ((x)>0 && MAX_COL-(x)<cur_col)    \
  685.                || ((x)<0 && MIN_COL-(x)>cur_col))    \
  686.                 return 0;            \
  687.             else
  688.  
  689. #define MAYBEREL(p) (*(p)=='[' && (isdigit((p)[1]) || (((p)[1]=='+' || (p)[1]=='-') && isdigit((p)[2]))))
  690.  
  691.     p= *ptr;
  692.     retr=0;
  693.     retc=0;
  694.     ended=0;
  695.     while(ended==0) {
  696.         switch(*p) {
  697.         case 'r':
  698.         case 'R':
  699.             if(retr) {
  700.                 ended++;
  701.                 break;
  702.             }
  703.             p++;
  704.             retr=R_CELL;
  705.             if(isdigit(*p)) {
  706.                 num=astol(&p);
  707.                 CK_ABS_R(num);
  708.                 retp->lr= retp->hr=num;
  709.             } else if(MAYBEREL(p)) {
  710.                 p++;
  711.                 num=astol(&p);
  712.                 CK_REL_R(num);
  713.                 retp->lr= retp->hr=num+cur_row;
  714.                 retr|=ROWREL;
  715.                 if(*p==':') {
  716.                     retr=RANGE|LRREL|HRREL;
  717.                     p++;
  718.                     num=astol(&p);
  719.                     CK_REL_R(num);
  720.                     retp->hr=num+cur_row;
  721.                 }
  722.                 if(*p++!=']')
  723.                     return 0;
  724.             } else if(retc || *p=='c' || *p=='C') {
  725.                 retr|=ROWREL;
  726.                 retp->lr= retp->hr=cur_row;
  727.             } else
  728.                 return 0;
  729.             if(*p==':' && retr!=(RANGE|LRREL|HRREL)) {
  730.                 retr= (retr&ROWREL) ? RANGE|LRREL : RANGE;
  731.                 p++;
  732.                 if(isdigit(*p)) {
  733.                     num=astol(&p);
  734.                     CK_ABS_R(num);
  735.                      retp->hr=num;
  736.                 } else if(MAYBEREL(p)) {
  737.                     p++;
  738.                     num=astol(&p);
  739.                     CK_REL_R(num);
  740.                     retp->hr=num+cur_row;
  741.                     retr|=HRREL;
  742.                     if(*p++!=']')
  743.                         return 0;
  744.                 } else
  745.                     return 0;
  746.             }
  747.  
  748.             if(retc)
  749.                 ended++;
  750.             break;
  751.  
  752.         case 'c':
  753.         case 'C':
  754.             if(retc) {
  755.                 ended++;
  756.                 break;
  757.             }
  758.             p++;
  759.             retc=R_CELL;
  760.             if(isdigit(*p)) {
  761.                 num=astol(&p);
  762.                 CK_ABS_C(num);
  763.                 retp->lc= retp->hc=num;
  764.             } else if(MAYBEREL(p)) {
  765.                 p++;
  766.                 num=astol(&p);
  767.                 CK_REL_C(num);
  768.                 retp->lc= retp->hc=num+cur_col;
  769.                 retc|=COLREL;
  770.                 if(*p==':') {
  771.                     retc=RANGE|LCREL|HCREL;
  772.                     p++;
  773.                     num=astol(&p);
  774.                     CK_REL_C(num);
  775.                     retp->hc=num+cur_col;
  776.                 }
  777.                 if(*p++!=']')
  778.                     return 0;
  779.             } else if(retr || *p=='r' || *p=='R') {
  780.                 retc|=COLREL;
  781.                 retp->lc= retp->hc=cur_col;
  782.             } else
  783.                 return 0;
  784.             if(*p==':' && retc!=(RANGE|LCREL|HCREL)) {
  785.                 retc= (retc&COLREL) ? RANGE|LCREL : RANGE;
  786.                 p++;
  787.                 if(isdigit(*p)) {
  788.                     num=astol(&p);
  789.                     CK_ABS_C(num);
  790.                      retp->hc=num;
  791.                 } else if(MAYBEREL(p)) {
  792.                     p++;
  793.                     num=astol(&p);
  794.                     CK_REL_C(num);
  795.                     retp->hc=num+cur_col;
  796.                     retc|=HCREL;
  797.                     if(*p++!=']')
  798.                         return 0;
  799.                 } else
  800.                     return 0;
  801.             }
  802.  
  803.             if(retr)
  804.                 ended++;
  805.             break;
  806.         default:
  807.             if(retr) {
  808.                 *ptr=p;
  809.                 retp->lc=MIN_COL;
  810.                 retp->hc=MAX_COL;
  811.                 if((retr|ROWREL)==(R_CELL|ROWREL))
  812.                     return (retr&ROWREL) ? (RANGE|LRREL|HRREL) : RANGE;
  813.                 else
  814.                     return retr;
  815.             } else if(retc) {
  816.                 *ptr=p;
  817.                 retp->lr=MIN_ROW;
  818.                 retp->hr=MAX_COL;
  819.                 if((retc|COLREL)==(R_CELL|COLREL))
  820.                     return (retc&COLREL) ? (RANGE|LCREL|HCREL) : RANGE;
  821.                 else
  822.                     return retc;
  823.             }
  824.             return 0;
  825.         }
  826.     }
  827.     if(!retr || !retc)
  828.         return 0;
  829.     *ptr=p;
  830.     if(retp->lr>retp->hr)
  831.         tmp=retp->lr,retp->lr=retp->hr,retp->hr=tmp;
  832.     if(retp->lc>retp->hc)
  833.         tmp=retp->lc,retp->lc=retp->hc,retp->hc=tmp;
  834.  
  835.     if((retr|ROWREL)==(R_CELL|ROWREL)) {
  836.         if((retc|COLREL)==(R_CELL|COLREL))
  837.             return retr|retc;
  838.         return (retr&ROWREL) ? (retc|LRREL|HRREL) : retc;
  839.     }
  840.     if((retc|COLREL)==(R_CELL|COLREL))
  841.         return (retc&COLREL) ? (retr|LCREL|HCREL) : retr;
  842.     return retr|retc;
  843. #endif
  844. }
  845.  
  846. #ifdef A0_REFS
  847. int
  848. str_to_col FUN1(char **,str)
  849. {
  850.     int ret;
  851.     char c,cc,ccc,cccc;
  852.  
  853.     ret=0;
  854.     c=str[0][0];
  855.     if(!isalpha((cc=str[0][1]))) {
  856.         (*str)++;
  857.         return MIN_COL + (isupper(c) ? c-'A' : c-'a');
  858.     }
  859.     if(!isalpha((ccc=str[0][2]))) {
  860.         (*str)+=2;
  861.         return MIN_COL+26 + (isupper(c) ? c-'A' : c-'a')*26 + (isupper(cc) ? cc-'A' : cc-'a');
  862.     }
  863. #if MAX_COL>702
  864.     if(!isalpha((cccc=str[0][3]))) {
  865.         (*str)+=3;
  866.         return MIN_COL+702 + (isupper(c) ? c-'A' : c-'a')*26*26 + (isupper(cc) ? cc-'A' : cc-'a')*26 + (isupper(ccc) ? ccc-'A' : ccc-'a');
  867.     }
  868.     if(!isalpha(str[0][4])) {
  869.         (*str)+=4;
  870.         return MIN_COL+18278 + (isupper(c) ? c-'A' : c-'a')*26*26*26 + (isupper(cc) ? cc-'A' : cc-'a')*26*26 + (isupper(ccc) ? ccc-'A' : ccc-'a')*26 + (isupper(cccc) ? cccc-'A' : cccc-'a');
  871.     }
  872. #endif
  873.     return 0;
  874. }
  875. #endif
  876.